System for generating a program using the language of individuals

ABSTRACT

A program generating system uses the language of an individual to write a program in expressions with words of the programmer himself which can easily be understood from the side of an application object, and to generate expressions according to a designated programming language from the program written with the words of the programmer himself. The program generating system has a first processor for transforming a user&#39;s linguistic expression into an initial role tree, a second processor for detailing and transforming a vocabulary expression of said initial role tree into a beginning role tree, a third processor for detailing and transforming said beginning role tree into an ending role tree, and a fourth processor for generating a source code of a programming language from said ending role tree. The first processor transforms the user&#39;s linguistic expression into a description in the form of the role tree. The second processor applies vocabulary transformation rules to the initial role tree to detail the vocabulary expression. The third processor applies role tree transformation rules to the beginning role tree to detail the beginning role tree. The fourth processor applies a set of patterns and a set of vocabularies to the ending role tree to generate a source code of a programming language.

TECHNICAL FIELD

The present invention relates to a system for generating a program usingthe language of individual persons, and more particularly to a programgenerating system which relies on the language of individual persons togenerate computer programs and is capable of accumulating and reusinggenerated programs in a generation of computer programs, based on alanguage transforming apparatus that employs a knowledge base.

BACKGROUND ART

When a computer program is generated, the programming process may becarried out efficiently by referring to programming experiences thathave been accumulated. Programming experiences of a programmer can beaccumulated by accumulating programs that have been generated by theprogrammer himself.

Heretofore, computer programs have been generated on the basis ofdirectly reusing programs that are described in high-level languages(e.g., 4 GL) designed for respective application fields. While it hasbeen customary practice to reuse documents such as specifications, theprocedure for reusing such documents is not necessarily automatized.

There has been known a language transforming apparatus which employs aknowledge base, for transforming a first linguistic description whichrepresents desired information processing in a certain application fieldthat is stated in a language used in the application field, into asecond linguistic description expressed in a certain computer programlanguage (Japanese laid-open patent publication No. 63-269228).According to the disclosed language transforming apparatus, one firstlinguistic description can be transformed into several second linguisticdescriptions, e.g., an application-side abstract program linguisticdescription and a computer program linguistic description. Since thefirst linguistic description can thus be transformed into differentsecond linguistic descriptions, the first linguistic description can bereused.

FIG. 1 of the accompanying drawings is a diagram showing a basicarrangement of such a language transforming apparatus which employs aknowledge base. As shown in FIG. 1, the language transforming apparatuscomprises a first linguistic description 1, a first role patternaccumulating means 2 for accumulating role patterns 3, a secondlinguistic description 4, a second role pattern accumulating means 5 foraccumulating other role patterns 6, a role assignment knowledgeaccumulating means 7 for accumulating role assignment knowledges 8 whichrepresent the corresponding relationship between the role patterns 3, 6that are accumulated in the first and second role pattern accumulatingmeans 2, 5, and a language transforming means 9 for transforming thefirst linguistic description 1 into the second linguistic description 4by referring to the role patterns 3, 6 and the role assignmentknowledges 8.

The language transforming means 9 is capable of obtaining the secondlinguistic description 4 which is desired from the first linguisticdescription 1 which is given, by using the role patterns 3 forunderstanding the first linguistic description 1 and the first rolepattern accumulating means 2 for storing the role patterns 3, using therole patterns 6 for understanding the second linguistic description 4and the second role pattern accumulating means 5 for storing the rolepatterns 6, and referring to the role assignment knowledges 8 thatrepresent assignments between the roles of role patterns in a firstlanguage and the roles of role patterns in a second language and therole assignment knowledge accumulating means 7.

FIG. 2 of the accompanying drawings illustrates, by way of example, anarrangement of the language transforming apparatus based on the basicarrangement shown in FIG. 1. In the arrangement shown in FIG. 2, thelinguistic form of an intermediate output of an information processingdescription is employed as the form of the first linguistic descriptionshown in FIG. 1. An information processing description from anapplication side is supplied as a description in compliance with thelinguistic form of an information processing description intermediateoutput 11 to the language transforming apparatus, in which the suppliedinformation processing description is transformed into a computerprogram intermediate output 13 by an intermediate output transformingprocessor 12. The computer program intermediate output 13 is then passedthrough a linguistic description generating processor 14, whichgenerates a computer program linguistic description 15 as the secondlinguistic description shown in FIG. 1. As with the computer programlinguistic description 15, an information processing linguisticdescription 17 from an application object side is generated as thesecond linguistic description shown in FIG. 1 by a linguisticdescription generating processor 16.

As described above, the above invention (Japanese laid-open patentpublication No. 63-269228) has shown that a conversion from the firstlinguistic description form into the second linguistic description formcan be achieved by the language transforming apparatus. However, it doesnot necessarily reveal a specific example of means for achieving such aconversion.

According to the conventional programming technology, accumulatedprograms are hardly used as they are, but are mostly required to berewritten, because of changes arising from circumstances of theapplication side, changes arising from circumstances of the computerside, and changes of program languages.

One program has three aspects, i.e., an aspect as seen from theapplication object side (an aspect as seen from the user), an aspect asseen from the computer side (an aspect as seen from the executing side),and an aspect of implementation. Rewriting a program requires that theprogram be understood simultaneously with respect to these threeaspects. Such a requirement is, however, responsible for increasing thedifficulty in rewriting the program. From the standpoint of rewriting aprogram, the program should have been written in expressions that caneasily be understood with respect to the aspect as seen from theapplication object side, which is not necessarily the case, however. Forexample, it is not necessarily simple to establish a sequence of causeand effect about what change of a program is brought about by a programmodification that is required under the circumstances of the applicationside. As a result, a process of rewriting a program may become moredifficult than a process of newly creating such a program, or anerroneous program may be produced due to a program rewriting error.

Therefore, it has been desired to be capable of writing a program inexpressions that can easily be understood from the application objectside, using user's own words, and of automatically generatingexpressions in an indicated programming language from a program that hasbeen written using user's own words.

DISCLOSURE OF THE INVENTION

It is therefore an object of the present invention to provide a programgenerating system which relies on the language of individuals forautomatically generating a program written in expressions that arecomposed of user's own words and can easily be understood from anapplication object side, using a programming language indicated by aprogram written with user's own words.

To achieve the above object, in accordance with the present invention,there is provided a program generating system for using the language ofan individual to generate a linguistic description expressed in aprogramming language from a linguistic description expressed in thelanguage of a user, comprising first processing means for transforming auser's linguistic expression into an initial role tree, secondprocessing means for detailing and transforming a vocabulary expressionof the initial role tree into a beginning role tree, third processingmeans for detailing and transforming the beginning role tree into anending role tree, and fourth processing means for generating a sourcecode of a programming language from the ending role tree.

According to the present invention, there is also provided a method ofidentifying delimiter symbols in a delimited file in a system having atext storage unit storing texts each structured to identify a given datapart from other data parts with sandwiching delimiter symbols anddelimiter definition parts positioned at the beginning of the texts andincluding extracted delimiter symbols used in the texts, in a sourcecode of a program and computer data to be processed by a program, adelimiter symbol processor, a data processor, and a delimiter symbolstorage unit, the method comprising the steps of starting to input thedelimiter symbols of the delimiter definition parts from the textstorage unit with the delimiter symbol processor, adding the order inwhich the delimiter symbols are inputted as symbol identifiers to thedelimiter symbols and registering the symbol identifiers and thedelimiter symbols in the delimiter symbol storage unit, starting toinput a text stored in the text storage unit while checking whetherthere is a delimiter symbol, searching the delimiter symbol storage unitusing a delimiter symbol as a key if the delimiter symbol is detectedwhile the text is being inputted, indicating the symbol identifier addedto the delimiter symbol and inputted data of the text inputted until thedelimiter symbol appears, to the data processor, recognizing thedelimiter symbol based on the symbol identifier and processing the dataas desired with the data processor, and if a next text is to beinputted, requesting the delimiter symbol processor to input the textfrom the text storage unit.

According to the present invention, there is further provided a methodof generating a program using the language of an individual to generatea linguistic description expressed in a programming language from alinguistic description expressed in the language of a user, comprisingthe steps of applying an intermediate output transforming process and anintermittent output detailing process to linguistic expressions of anindividual to transform the linguistic expressions of the individualinto linguistic expressions inherent in a field in an initial stage,applying an intermediate output transforming process and an intermittentoutput detailing process to the linguistic expressions inherent in thefield to transform the linguistic expressions inherent in the field intostandard linguistic expressions in an intermediate stage, and applyingan intermediate output transforming process and an intermittent outputdetailing process to the standard linguistic expressions to transformthe standard linguistic expressions into linguistic expressionsrepresenting computer operations in a final stage, finally obtainingcomputer program language descriptions in a predetermined programminglanguage.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram showing a basic arrangement of a languagetransforming apparatus using a knowledge base;

FIG. 2 is a block diagram showing an example of an arrangement of thelanguage transforming apparatus based on the basic arrangement shown inFIG. 1;

FIG. 3 is a block diagram showing a system according to the presentinvention, based on a language transforming apparatus using a knowledgebase;

FIG. 4 is a block diagram illustrative of a programming process based ona program generating system which relies on an individual's language;

FIG. 5(A), FIG. 5(B) and FIG. 5(C) are block diagrams showing anembodiment of a program generating system which relies on anindividual's language according to the present invention;

FIG. 6 is a diagram showing an example of the content of an initialdocument file in which an initial document is described;

FIG. 7(A) and FIG. 7(B) are flowcharts showing details of a processingsequence of a first processor;

FIG. 8 is a flowchart showing details of conditional statementprocessing;

FIG. 9 is a flowchart showing details of a sequence for processing acomposite statement;

FIG. 10 is a diagram showing the structure of a role tree;

FIGS. 11(A) through 11(D) are diagrams showing formats in which viewdefinitions are permitted;

FIG. 12 is a diagram showing a format in which a view definition isinhibited;

FIG. 13 is a diagram showing an example of a role tree file;

FIG. 14 is a diagram showing an example of a format in which a role treeis permitted;

FIGS. 15(A) through 15(c) are diagrams showing formats in which roletrees are inhibited;

FIG. 16 is a diagram showing an initial role tree which the firstprocessor generates from an initial document;

FIG. 17 is a diagram showing an example of the content of a vocabularytransformation rule file;

FIG. 18 schematically shows a processing sequence of a second processor;

FIG. 19 is a flowchart of a processing sequence of applying rules andtransforming a vocabulary;

FIG. 20 is a flowchart of a processing sequence for matching apre-conditional part and a role tree vocabulary;

FIG. 21 is a flowchart of a processing sequence for constructing acharacter string to replace a vocabulary from the post-conditional partof a rule and the value of a variable;

FIG. 22 is a diagram showing the content of a beginning role tree filethat is generated by the second processor when vocabulary transformationrules are applied to an initial role tree;

FIG. 23 is a diagram showing the content of a transformation controlfile used for a third processor to generate an ending role tree;

FIG. 24 is a diagram showing a format of role tree transformation rules;

FIGS. 25(A) through 25(D) are diagrams showing various variables thatcan be contained in role tree transformation rules;

FIG. 26 is a diagram showing the structure of a role tree transformationrule file;

FIGS. 27(A) and 27(B) are diagrams showing a first set of rules forgenerating a program structure applied to a beginning role tree;

FIG. 28 is a diagram showing a second set of rules for describing animplementing procedure applied to a beginning role tree;

FIGS. 29(A) and 29(B) are diagrams showing a third set of rules fordescribing a process related to refining usage of standard computerprogram parts applied to a beginning role tree;

FIGS. 30(A) and 30(B) are diagrams showing an ending role tree which thethird processor generates from a beginning role tree;

FIG. 31 is a diagram showing a process of expressing a role tree in thethird processor;

FIG. 32 is a diagram showing a process of expressing role treetransformation rules in the third processor;

FIG. 33 is a diagram showing a variable table for holding the values ofvariables contained in a role tree transformation rule;

FIG. 34 is a flowchart of a processing sequence of the third processor;

FIG. 35(A) and FIG. 35(B) are flowcharts of a procedure for matching apre-conditional part;

FIG. 36 is a flowchart of a procedure for matching four items whichconstitute a view condition of a role tree transformation rule with arole tree;

FIG. 37 is a flowchart of a procedure for constructing a partial roletree from the post-conditional part of a role tree transformation rule;

FIG. 38(A) and FIG. 38(B) are flowcharts of a procedure for forciblyadding four items;

FIG. 39 is a diagram showing the content of a expression generationcontrol file used for a fourth processor to generate computerprogramming linguistic descriptions from an ending role tree;

FIG. 40 is a diagram showing a set of patterns inherent in problems;

FIG. 41(A) and FIG. 41(B) are diagrams showing a set of common-usepatterns by way of example;

FIG. 42 is a diagram showing a set of vocabularies representative of acollection of object names inherent in problems, by way of example;

FIG. 43 is a diagram showing, by way of example, a set of vocabulariesrepresentative of a collection of object names used by a macro assemblerprogram;

FIG. 44 is a diagram showing a top view file by way of example;

FIG. 45(A) FIG. 45(B) are diagrams showing, by way of example, computerprogram language descriptions which are generated from an ending roletree by a fourth processor;

FIG. 46 is a flowchart of a processing sequence of the fourth processor;

FIG. 47(A) and FIG. 47(B) are flowcharts of a procedure for generatingan expression character string;

FIG. 48 is a flowchart of a procedure for generating a character stringwith respect to a vocabulary view;

FIG. 49(A), FIG. 49(B) and FIG. 49(C) are flowcharts of a process forsuccessively outputting rows of keys of an intermediate view characterstring;

FIG. 50(A) and FIG. 50(B) are flowcharts of a process of determining arelative position in an indefinite-length role pattern character string;

FIG. 51 is a flowchart of a sequence for processing the tail of apattern character string;

FIG. 52 is a diagram showing, by way of example, the generation of amultilingual document by changing patterns;

FIG. 53 is a diagram showing the principles of a means for identifyingdelimiter symbols;

FIG. 54 is a flowchart of a process of processing delimiter symbols;

FIG. 55 is a diagram of a system for processing data including delimitersymbols;

FIG. 56 is a diagram showing the structure of document files;

FIG. 57(A) and FIG. 57(B) are flowcharts of a procedure for extracting areferred-to statement sandwiched between delimiter symbols; and

FIG. 58 is a diagram illustrative of symbol identifiers registered in adelimiter symbol storage unit 53.

BEST MODE FOR CARRYING OUT THE INVENTION

FIG. 3 shows a system according to the present invention, based on alanguage transforming apparatus using a knowledge base. As shown in FIG.3, the system according to the present invention has a mechanism forproducing an information processing description intermediate output froman information processing linguistic description. Specifically, thesystem includes a beginning information processing descriptionintermediate output 11a, an intermediate output transforming processor12a, a computer program intermediate output 13a, a linguisticdescription generating processor 14a, a computer program linguisticdescription 15a, a linguistic description generating processor 16a, andan application-side abstract program linguistic description 17a, whichare all of the conventional nature, and additionally includes anintermediate description generating processor 19 for transforming aninformation processing linguistic description 18 into an initialinformation processing description intermediate output 20, and anintermediate output refining processor 21 for transforming the initialinformation processing description intermediate output 20 into thebeginning information processing description intermediate output 11a.

The intermediate description generating processor 19 serves to transformthe information processing linguistic description 18, which allows theuser to write a program with his own words, into the initial informationprocessing description intermediate output 20, which has a datastructure required for transformation. The intermediate descriptiongenerating processor 19 effects a transformation process that is areversal of the transformation process carried out by the linguisticdescription generating processors 14a, 16a. With the intermediatedescription generating processor 19, the user is allowed to write aprogram using his own words.

FIG. 4 illustrates a programming process based on a program generatingsystem which relies on an individual's language. The programming processis such a process that the processing by the intermediate outputtransforming processor 12a and the intermediate output refiningprocessor 21 shown in FIG. 3 is applied a plurality of times totransform information processing linguistic descriptions written in theuser's language successively into computer program linguisticdescriptions.

In FIG. 4, the programming process is composed of a series oftransformation stages. In an initial stage 22, an individual'slinguistic expression is transformed into an intermediate descriptionand a linguistic expression inherent in an individual field. In anintermediate stage 23, the linguistic expression inherent in theindividual field is transformed into a standard linguistic expression.In a final stage 24, the standard linguistic expression is transformedinto a linguistic expression representing a computer operation, thusfinally producing a computer program linguistic description in a certainprogramming language.

Stated otherwise, the programming process is a process of bringingindividual's words into a standard world in the language transformingapparatus, and then transforming the words into an individualprogramming language. In various stages of the intermediate outputtransforming processing, abstract program linguistic expressions can beproduced using the linguistic description generating processor.

FIGS. 5(A) through 5(C) show an embodiment of a program generatingsystem which relies on an individual's language according to the presentinvention. The program generating system includes an initial document 30corresponding to the first linguistic description in the languagetransforming apparatus, a first processor 31, initial role trees 32corresponding to the role patterns in the language transformingapparatus, a second processor 33, beginning role trees 34, a thirdprocessor 35, ending role trees 36, a fourth processor 37, a computerprogram source code 38 corresponding to the second linguisticdescription in the language transforming apparatus, a set 39 ofvocabulary transformation rules corresponding to a portion of the roleassignment knowledges in the language transforming apparatus, a set 40of role tree transformation rules, a set 41 of patterns, and a set 42 ofvocabularies. Preferably, the program generating system also includes atransformation control file 43 composed of a list of the names of manyfiles of the set 40 of role tree transformation rules, an expressiongeneration control file 44, and a top view file 45.

The components of the program generating system shown in FIGS. 5(A) and5(C) are illustrated as being related to those of the system shown inFIG. 3. Specifically, the initial document 30 corresponds to theinformation processing linguistic description 18, the first processor 31to the intermediate description generating processor 19, the initialrole trees 32 to the initial information processing descriptionintermediate output 20, the second processor 33 to the intermediateoutput refining processor 21, the beginning role trees 34 to thebeginning information processing description intermediate output 11a,the third processor 35 to the intermediate output transforming processor12a, the ending role trees 36 to the computer program intermediateoutput 13a, the fourth processor 37 to the linguistic descriptiongenerating processor 14a, and the computer program source code 38 to thecomputer program linguistic description 15a.

FIG. 6 shows an example of the content of an initial document file inwhich an initial document 30 is described. The example shown in FIG. 6illustrates a situation for calculating a change. The initial document30 comprises a symbol string composed of delimiter symbols and a row ofcharacters separated by delimiter symbols that belong to the symbolstring. The delimiter symbols are defined by being sandwiched betweenmeta delimiters "▪" at the beginning of the file, and characterized bythe relative position in the symbol string and by being uniquelyidentified in the string of delimiter symbols. Insofar as the aboveconditions are satisfied, delimiter symbols can be selected withfreedom. A file in which a string of delimiter symbols is defined at thebeginning and which is processed by being signified depending on theorder of appearance of the delimiter symbols is referred to as a"delimiter file".

Each row of characters separated by delimiter symbols, together with thedelimiter symbol positioned immediately following the same, is called a"word". A file composed of rows of delimiter symbols and rows of wordsis called a "word file".

The delimiter symbols ranging from the first delimiter symbol "=" to thesixth delimiter symbol "#" are used to describe an initial role tree 32as an information processing description intermediate output.

In the initial document, a statement is assumed to end with ".". Aportion from "" to a position immediately before next "" is a single"part", a portion from "" to next "" is the name of that part, and aportion from "" to next "" is a row of statements.

A row of characters which has "" at the beginning, ends with ".", andcontains no other delimiter symbols is regarded as representing acomment.

A row of characters which does not have "" at the beginning, ends with".", and contains no other delimiter symbols is regarded as representingone statement written by user's language expressions.

A row of characters which does not have "" at the beginning, has "→"somewhere in the middle, ends with ".", and contains no other delimitersymbols is regarded as representing a conditional statement. A row ofcharacters following "→" and ending with "." in characters thatrepresent a conditional statement, including ".", may be replaced with arow of characters beginning with "{" and ending with "}". A row ofcharacters beginning with "{" and ending with "}" may contain a row ofstatements which may include a commentary statement and a conditionalstatement.

Sentences are classified into three types, i.e., a commentary statementfrom the symbol "" to the symbol ".", a conditional statement having apattern xxx→{yyy}, and an ordinary statement. The portion of theconditional statement which is left to "→" serves as a condition, andthe portion thereof from "{" to "}" as the content of an action. Thecontent of an action from "{" to "}" is represented by a row ofstatements.

The name of the initial document file is indicated by "tst.idc" in FIG.6.

In FIG. 5(A), the initial document 30, which is a user's languagerepresentation, is inputted to the first processor 31, which thengenerates an initial role tree 32 using the delimiter symbols.

FIG. 7(A), FIG. 7(B), FIG. 8, and FIG. 9 are illustrative of aprocessing sequence of the first processor 31 for converting an initialdocument file into an initial role tree.

FIG. 7(A) and FIG. 7(B) are flowcharts showing details of a processingsequence of the first processor 31. The first processor 31 is composedof a program entitled "makeTree.exe" that operates under MS-DOS, forexample. By executing this program, the first processor 31 receives aninitial document 30 and generates an initial role tree 32 according tothe rules of the delimiter symbols.

When a word file is inputted, a string of characters up to a nextdelimiter symbol and that delimiter symbol are entered. Depending on theresult of determination of the delimiter symbol, control branches intosequences for processing a commentary statement, a simple statement(other than commentary and conditional statements), and a conditionalstatement. Specifically, if the delimiter symbol is a comment delimiter"", then a view of commentary vocabulary is generated, and the word fileis entered. If the delimiter symbol is a simple statement delimiter ".",then a view of simple statement vocabulary is generated, and the wordfile is entered. If the delimiter symbol is a conditional delimiter "→",then a conditional statement pattern is generated, and the word file isentered. The generation of a conditional statement pattern isillustrated in FIG. 8.

A commentary statement is processed differently depending on whether itappears at the beginning of the initial document or not. If a commentarystatement appears at the beginning of the initial document, then a viewof commentary vocabulary is first generated, and thereafter it isdetermined whether the statement is a commentary statement, a simplestatement, or a conditional statement.

A row of statements which can be put together as one group can be givena name. A pattern which has a name and a row of statements is referredto as a part. A role tree is formed of a row of such parts.

FIG. 8 is a flowchart of showing details of conditional statementprocessing. In the conditional statement processing, of a row ofcharacters representing a conditional statement, a character string fromthe beginning of the statement to a position immediately before thesymbol "→" is used to generate a conditional portion of a conditionalstatement pattern. A character string following the delimiter symbol "→"and ending with the delimiter symbol "." is processed as a simplestatement. A character string following the delimiter symbol "→" andbeginning with "{" and ending with "}" is processed as a compositestatement. Details of a sequence for processing a composite statementare shown in FIG. 9.

FIG. 9 is a flowchart showing details of a sequence for processing acomposite statement. In processing a composite statement, the type of astatement is determined based on the type of a delimiter symbol, andcontrol branches into different processing sequences for differentstatement types. If a statement is a conditional statement, then thesequence of processing a conditional statement shown in FIG. 8 is calledrecursively to process the conditional statement.

FIG. 10 is a diagram showing the structure of a role tree. The structureof a role tree will be described below with reference to FIG. 10. A roletree is a set of view definitions. A view definition is composed of aview and a view content which are interconnected by the delimiter symbol"=". The view content comprises a pattern and a row of role assignmentssandwiched between the delimiter symbol "(" and the delimiter symbol ")"The row of role assignments is a string of role assignments separated bythe delimiter symbol "," The role assignments are composed of a role andsubviews that are interconnected by the delimiter symbol ":".

In the illustrated example, a pattern "change calculation" is used for aview "situation to calculating change", and it is assumed that threeroles, "amount given", "amount to pay", and "change", appear in thepattern. In the view "situation to calculating change", it is supposedthat the role of the amount given is played by Y, the role of the amountto pay by Z, and the role of the change by X. The combinations of rolesand subviews "change:X" "amount to pay:Z" and "amount given:Y" serve asrole assignments, respectively, and the row of such combinations alsoserves as a role assignment.

In a set of view definitions that constitutes a role tree, a view whichappears as a subview only and does not appear as a view is called avocabulary view, and a view which appears as a view only and does notappear as a subview is called a top view. A view which is neither a topview nor a vocabulary view is called an intermediate view. A role treeis regarded as a set of paths extending from a top view throughintermediate views to vocabulary views.

FIGS. 11(A) through 11(D) are diagrams showing formats that allow viewdefinitions. FIG. 11(A) shows an example in which role assignments canbe switched around in order. In the illustrated example, "amountgiven:Y" and "change:X" are switched around in order.

FIG. 11(B) shows an example in which a view name is duplicated as apattern name. A view name may be duplicated as a pattern name because aview and a pattern that are described in respective different positionscan be identified by their positions. Since views can be distinguishedfrom each other if they are different from each other and a pattern canbe distinguished from another pattern if they are different from eachother, a view and a pattern may belong to one character string. Rolescan also be distinguished even if the same name as roles is used by aview or a pattern.

FIG. 11(C) shows an example in which a role assignment string composedonly of role assignments omitting role names including the delimitersymbol ":" is written. In the examples of view definitions shown inFIGS. 11(A) and 11(B), the role names are explicitly indicated, and sucha pattern is referred to as a "fixed-length pattern". On the other hand,a pattern with no explicitly indicated role names is referred to as an"indefinite-length pattern". There are only two patterns, i.e., afixed-length pattern and an indefinite-length pattern, that can be usedin role trees. In each processing step, the indefinite-length pattern isautomatically assigned a special role (manipulatable by the system only)whose role name is called "ordering role". Inasmuch as the order inwhich subviews are arranged is automatically caused to correspond to theorder in the pattern, an indefinite-length pattern is used forexpressing some ordering.

FIG. 11(D) shows an example in which a string of empty role assignmentsis permitted. As far as an indefinite-length pattern is concerned, aview definition free of any role assignments is permitted, which iscalled an empty subview.

FIG. 12 is a diagram showing a format in which a view definition isinhibited. In the illustrated example, the role "change" is "X" or "W",and it is inhibited for the same role to be played simultaneously by aplurality of objects.

FIG. 13 is a diagram showing an example of a role tree file. The roletree file is a delimited-word file which is composed of a definition ofdelimiter symbols at the beginning of the file and a set of viewdefinitions.

FIG. 14 is a diagram showing an example of a format in which a role treeis permitted. The example illustrates a nested representation in which aview content of a pattern name "change calculation" is substituted forone of the subviews in a row. The system solves such a nestedrepresentation into a basic form of role tree. In such a case, since anintermediate view name is newly required, a delimiter symbol called asystem sharp, e.g., "#", is used to change the nested representation tothe basic form.

FIGS. 15(A) through 15(D) are diagrams showing formats in which a roletree is inhibited. There are three conditions to be satisfied forgathering view definitions into a role tree. The first condition is thata double view definition is inhibited as shown in FIG. 15(A).Specifically, there should not be another view definition having thesame view as that on the left-hand side of "=" of a view definition, andthe uniqueness of a definition view should be maintained.

The second condition for a role tree is that a loop is inhibited asshown in FIG. 15(B). Between a "definition view" on the left-hand sideof a view definition and a "subview" appearing on the right-hand sidethereof, there is a role path from the definition view to the subview.The role path can be traced in order. For example, there is a role pathfrom the definition view of giving/receiving a payment toward thesubview of a situation for calculating change, and there is also a rolepath from the definition view of giving/receiving a payment toward asubview X. In such a case, it is said that there is a role path from thedefinition view of giving/receiving a payment toward the subview X.

If a direction toward a definition view is "upward" and a directiontoward a subview is "downward" in a role path, then the loop inhibitingcondition is such that any "top view" is necessarily reached when therole path is traced "upward" from any optional subview. A role treecorresponds to the fact that the path is "not looped". A structure inwhich any paths from a leaf node to a route node are not looped and anyintermediate nodes do not overlap each other, is said to be "treestructure" in the art of computer science. A role tree has such a treestructure.

The third condition for a role tree is the uniqueness of a pattern asshown in FIG. 15(C). The same pattern as others can be allocated toanother definition view. In such a case, if one pattern is of afixed-length form, the other has to be of a fixed-length form having thesame role, and if one pattern has an indefinite length, then the otherhas to have an indefinite length.

FIG. 16 is a diagram showing an initial role tree which the firstprocessor generates from an initial document. In FIG. 16, an initialrole tree file has a file name "tst.tr1". The initial role tree 32describes a structure relative to the manner in which user's languageexpressions are arranged. The user's language expressions are assignedas vocabulary views (names indicating particular individuals) of a roletree.

The commentary statement beginning with the delimiter symbol "" isassigned to the position of a role name "content" of a commentarypattern. The conditional statement is converted into a conditionalaction pattern. The row of characters up to the appearance of thedelimiter symbol "→" is assigned to the position of a role name"condition". The row of characters from "{" to "}" is used to write aplurality of statements that are executed when a condition is satisfied.The plurality of statements are converted into the elements of a row ofpatterns assigned to the position of the role name "content". A row ofuser's expressions recognized as a part is converted into the elementsof a row of patterns assigned to the position of the role name "content"of a partial pattern. The character string sandwiched between "" and ""is assigned as a name for this row to the position of a role name"name".

The second processor 33 shown in FIG. 5(A) is composed of a programentitled "decvoc2.exe" that operates under MS-DOS, for example. Byexecuting this program, the second processor 33 transforms the initialrole tree 32 to generate a beginning role tree 34 using the set 39 ofvocabulary transformation rules. The set 39 of vocabulary transformationrules will be described below.

FIG. 17 is a diagram showing an example of the content of a vocabularytransformation rule file. The vocabulary transformation rule file has afile name "tst.ivr". A row of characters up to a delimiter symbol "▴"represents one rule. The row of characters from the beginning to thedelimiter symbol "→" in one rule represents the left-hand side of therule, and serves as a pre-conditional part. The row of characters fromthe delimiter symbol "→" to the delimiter symbol "▴" represents theright-hand side of the rule, and serves as a post-conditional part. Therow of characters sandwiched between the delimiter symbols "" and "",with these delimiter symbols inclusive, represents a variable. Thevariable as a whole is regarded as a delimiter symbol, and the rows ofcharacters on the left-hand side of the rule, which are separated by thevariable, are called keys, respectively. The keys are used as a clue fordetermining the value of the variable by matching the left-hand side ofthe rule with the vocabulary view. If the matching is successful, then acertain character string is obtained as the value of the variable. Thevalue of the variable obtained by the matching is substituted in theposition of the variable on the right-hand side of the rule, thusgenerating a character string from the right-hand side of the rule. Thegenerated character string is used as a character string for replacingthe vocabulary view.

FIGS. 18 through 21 are flowcharts showing details of a processingsequence of the second processor.

FIG. 18 schematically shows a processing sequence of the secondprocessor. The second processor 33 searches the initial role tree 32,and each time the second processor 33 finds a vocabulary view, itattempts to apply vocabulary transformation rules. The initial role tree32 is processed as a set of words (rows of characters separated bydelimiter symbols). The second processor 33 successively reads words,determines subviews with delimiter symbols, and apply vocabularytransformation rules to the subviews.

FIG. 19 is a flowchart of a processing sequence of applying rules andtransforming a vocabulary. Each rule is composed of a pre-conditionalpart and a post-conditional part. The pre-conditional part is appliedsuccessively to vocabulary views. If the rule application is successful,then a new vocabulary is generated from the post-conditional part. Ifthe rule application fails, the vocabulary is not rewritten, and iswritten as it is.

FIG. 20 is a flowchart of a processing sequence for matching apre-conditional part and a role tree vocabulary. It is confirmed thatkeys on the left-hand side of a rule appear in the vocabulary to bematched in the same order as they appear on the left-hand side of therule. First, the first key on the left-hand side of the rule is matchedwith the vocabulary, and then the final key (end key) on the left-handside of the rule is matched with the vocabulary. Thereafter, remainingkeys are matched with the vocabulary with respect to a character stringthat is left in the vocabulary by matching. Each time one key ismatched, if the matching is successful, the key is regarded as onedelimiter character, and the row of characters on the vocabularyseparated by the key is adopted as the value of a variable. Each time akey is matched, a search interval to be matched with a next key isreduced. The matching is successful if all the keys on the left-handside of the rule appear in the vocabulary in the same order as theyappear on the left-hand side of the rule. The matching fails if any ofthe keys on the left-hand side of the rule is not located on thevocabulary view in the order in which it appears on the left-hand sideof the rule.

FIG. 21 is a flowchart of a processing sequence for constructing acharacter string to replace a vocabulary from the post-conditional partof a rule and the value of a variable. The keys of the post-conditionalpart of the rule and the value of the variable are outputted in theorder in which they appear in the post-conditional part, thusconstructing a transformation vocabulary. The process is ended when thevariable KC exceeds the number of keys of the post-conditional part.

FIG. 22 is a diagram showing the content of a beginning role tree thatis generated by the second processor when vocabulary transformationrules are applied to an initial role tree. The beginning role tree has afile name "tst.tr2" By the application of the vocabulary transformationrules, the vocabulary of the initial role tree 32 is detailed on thebeginning role tree 34 shown in FIG. 22, as follows:

"RECEIVE CASH IN PAYMENT OF AMOUNT TO PAY" is detailed into "RECEIVECASH (AMOUNT TO PAY:AMOUNT TO PAY, CASH:CASH)",

"RETURN TO GIVING/RECEIVING OF AMOUNT TO PAY" is detailed into "PROCEED(DESTINATION: GIVING/RECEIVING OF AMOUNT TO PAY)",

"CASH SMALLER THAN AMOUNT TO PAY" is detailed into "COMPARE AMOUNT(SMALLER:CASH, GREATER:AMOUNT TO PAY)",

"BILL FOR SHORTAGE" is detailed into "BILL FOR SHORTAGE (AMOUNT TOPAY:AMOUNT TO PAY, CASH:CASH)",

"CASH GREATER THAN AMOUNT TO PAY" is detailed into "COMPARE AMOUNT(GREATER:CASH, SMALLER:AMOUNT TO PAY)",

"WRAP AND GIVE ARTICLE" is detailed into "GIVE ARTICLE"(ARTICLE:ARTICLE),

"CALCULATE CHANGE AGAINST RECEIVED PAYMENT" is detailed into "CALCULATECHANGE (RECEIVED AMOUNT:CASH, AMOUNT TO PAY:AMOUNT TO PAY,CHANGE:CHANGE), and

"GIVE CHANGE" is detailed into "GIVE CHANGE (CHANGE:CHANGE).

The third processor 35 transforms the beginning role tree 34 into anending role tree 36, which is a role tree with respect to the computerprogram source code 38 that corresponds to the second linguisticdescription, using the set 40 of role tree transformation rules. Inorder to manage file groups used for transformation, the third processor35 refers to the transformation control file 43.

FIG. 23 is a diagram showing the content of a transformation controlfile used for the third processor to generate an ending role tree. Thetransformation control file has a file name "tst.icn". Following thestring of delimiter symbols, the designation of an input role tree file,the designation of an output role tree, and the designation oftransformation rule files are defined. In the illustrated example, threefiles "begin.ru1", "tst.ir1", and "end.ru1" are designated astransformation rule files.

FIG. 24 is a diagram showing a format of role tree transformation rules.In the illustrated example, a portion extending from "{" to "}"constitutes one rule. One rule is composed of a pre-conditional part anda post-conditional part. A portion extending from "{" to "→" constitutesa pre-conditional part. A portion extending from "→" to "}" constitutesa post-conditional part. Both the preconditional part and thepost-conditional part are composed of the view definition shown in FIG.10 or a set of view definitions preceded by the delimiter symbol "˜".

The pre-conditional part represents a matching condition. Specifically,a view definition which matches the pre-conditional part is searched forin the role tree. The view definition which matches the pre-conditionalpart is brought as the value of a matching variable into thepost-conditional part. In the post-conditional part, a new viewdefinition is produced based on the value, and "forcibly added" to therole tree. The forced addition is a characteristic nature of the roletree transformation such that a new view definition is added so as tosatisfy the basic conditions of the role tree (three conditions of viewsand a condition for role assignment) and also to give priority to theview definitions to which a new view definition is to be added. When anew view definition is added, an old definition that has becomeinconvenient is deleted. In the above example, this corresponds to thereplacement of the conditional action pattern of the matched viewdefinition with an ifCarry pattern.

A matching variable which is not present in a preconditional part mayappear in a post-conditional part. For example, "¥new" shown in FIG. 24is such a matching variable. In this case, a system sharp is used toautomatically generate a totally novel character string (a characterstring with a system sharp at its beginning).

A variable may be contained in each of a view, a pattern, a role, and asubview which constitute a view definition.

FIGS. 25(A) through 25(D) are diagrams showing various variables thatcan be contained in role tree transformation rules. In FIGS. 25(A)through 25(D), rows of characters preceded by the symbol "¥", written inthe positions of a view name, a role pattern name, a rule name, and asubview name, are variables for matching one value. As shown in FIG.25(B), the symbol "˜" at the beginning of the view name represents"existence negation", i.e., indicates that there is no view definitionof ¥y=block (label:¥name). In the description of the post-conditionalpart, it means deletion.

A block variable preceded by the symbol "@" may be placed in thesubview. The symbol "@" is a matching variable which takes its valuefrom a row of successive subviews of an indefinite-length pattern.Whereas the variable "¥" matches only one value, the variable "@"matches a cluster of elements in a row. While the variable "¥" can matcha view variable, a pattern variable, and a role variable, the variable"@" matches only a row of successive subviews of an indefinite-lengthpattern. In FIG. 25(C), a row of subviews preceding "¥w" matches "@C1",and a row of subviews following "¥w" matches "@C2". The variable "@"also matches a row of empty subviews.

A pattern and a role can simultaneously be represented by "*", and canbe handled as a blank variable. The blank variable has its value takenfrom a path on a role tree which interconnects a view and a subview ofthe view definition which contains the blank variable. In FIG. 25(D),this corresponds to the condition that "there is a role path from a view"¥myBody" to a view ¥x"".

FIG. 26 is a diagram showing the structure of a role tree transformationrule file. A set of transformation rules is composed of a row oftransformation rules. One transformation rule can be matched in aplurality of locations on a role tree. A transformation rule is appliedrepeatedly to a role tree in order to be matched with all applicablelocations on a role tree. If the application fails, a new rule isapplied. When there are no longer available any rules to be applied, theapplication of a set of transformation rules to a role tree comes to anend.

The application of a transformation rule to a role tree is defined asfollows: It is assumed that when the matching of all view definitionswhich constitute the preconditional part of one rule with a role tree issuccessful, the matching of the pre-conditional part of the rule withthe role tree is successful. When the matching of the preconditionalpart of the rule with the role tree is successful, a partial role treeis constructed from the post-conditional part of the rule, and forciblyadded to the role tree.

The matching of one view definition with a role tree is defined asfollows: First, the matching of a view definition free of the delimitersymbol "˜" with a role tree is defined. When a variable which one viewdefinition of a pre-conditional part has is set to a suitable value, ifit is successful to obtain one element of a view definition thatconstitutes a role tree to be matched, then the matching is assumed tobe successful. If it fails to achieve agreement with any viewdefinitions of the role tree, then the matching is unsuccessful. If thematching is successful, then the value established for the matching isdetermined as the value of the variable at the time of the matching.Then, the matching of a view definition with the delimiter symbol "˜"with a role tree is defined. A view definition portion from which thedelimiter symbol "˜" is removed is taken out, and this view definitionis matched with the role tree. If the matching is successful, then thematching of the overall view definition with the delimiter symbol "˜" isassumed to be a failure. Conversely, if the matching is unsuccessful,then the matching of the overall view definition with the delimitersymbol "˜" is assumed to be a success. In the matching of the viewdefinition with the delimiter symbol "˜" the matching process does notdetermine the value of a variable irrespective of whether the matchingis successful or fails.

By substituting the value of the variable determined by the matching ofthe pre-conditional part for the variable in the post-conditional part,there is constructed a set of view definitions from the post-conditionalpart. The set of view definitions is added as a portion of the role treeto the role tree. If any view definitions of the post-conditional partdo not have the delimiter symbol "˜" then a partial tree constructedfrom the view definitions is added to the role tree. In order to assurethat the tree structure of the role tree will not be destroyed by theaddition of the set of view definitions and that the addition willalways contribute to the transformation of the tree structure, if theaddition would destroy restraint conditions to be met by the role tree,then a partial tree which is responsible is deleted from the old roletree, and thereafter the set of view definitions is added. If viewdefinitions of the post-conditional part have the delimiter symbol "˜",then the partial role tree constructed from the post-conditional part isdeleted from the role tree. That is, the delimiter symbol "˜" appearingin the view condition of the post-conditional part represents a negatingoperation relative to the addition.

FIGS. 27(A) and 27(B) are diagrams showing a first set of rules forgenerating a program structure applied to a beginning role tree. Therole tree transformation rule file has a file name "begin.ru1". Thebeginning role tree imparts a control flow structure to a structurerelative to a row of statements to be described, thus generating aprogram structure. The transformation rules can be reused as generalrewriting rules.

The role tree transformation rules for generating a program structurehave 15 delimiter symbols "▪=(:,)#{˜→} ¥*@₋₋ ▪". The delimiter symbol"▪" is a meta delimiter. The delimiter symbols "=(:,)#" are the same asthose used in a role tree. Among the remaining delimiter symbols "{˜→}¥*@₋₋ " are peculiar to these transformation rules.

One unit of transformation rule extends from "{" to "}". A portionextending from "}" to "{" serves as the name of a transformation rule,and is considered here as to be a comment. Anything but the delimitersymbols may be written as the name of a transformation rule. Atransformation rule written from "{" to "}" is divided into apre-conditional part and a post-conditional part by the delimiter symbol"→". A portion of the transformation rule which extends from "{" to "→"serves as a pre-conditional part, and a portion of the transformationrule which extends from "→" to "}" serves as a post-conditional part.They are described in the format of the role tree transformation rulesshown in FIG. 24.

FIG. 28 is a diagram showing a second set of rules for describing animplementing procedure applied to a beginning role tree. The role treetransformation rule file has a file name "tst.ir1". A computer operationis caused to correspond to a representation inherent in the problem of achange calculation on a role tree, rewriting the beginning role tree. Acash receiving pattern is realized by the input of a numerical valuefrom a standard input, and billing for a shortage is realized by theoutput of a numerical value to a standard output. A change calculationis realized by a subtraction, giving a change is realized by the outputof a numerical value to a standard output, and giving an article isrealized by the indication of characters to a standard output.

FIGS. 29(A) and 29(B) are diagrams showing a third set of rules fordescribing a process related to refining usage of standard computerprogram parts applied to a beginning role tree. In FIG. 29(A), the roletree transformation rule file has a file name "end.ru1". Referring tocomputer program parts written in an object programming language, andsupplementing program descriptions (variable preparations, labelassignments, etc.) required to refer to computer program parts, thedescription of computer operation on the role tree is transformed intoan ending role tree which describes the structure of a computer program.The transformation rules can be reused as general rewriting rules.

In the illustrated example, there is shown a set of transformation rulesfor transforming a beginning role tree into an intermediate language fora macro assembler. Rules for converting a beginning role tree into aprogram description peculiar to a macro assembler are described. Forexample, rules for replacement with numerical standard inputs for themacro assembler are first described, rules for generating requiredbuffer areas are described, and rules for generating the declaration ofvariables are described.

FIGS. 30(A) and 30(B) are diagrams showing an ending role tree which thethird processor generates from a beginning role tree. The ending roletree file has a file name "tst.tr3". As a result of applying the set 40of role tree transformation rules to the beginning role tree 34, thethird processor 35 obtains a role tree for generating expressions in amacro assembler programming language from the beginning role tree 34.

FIG. 31 is a diagram showing a process of expressing a role tree in thethird processor. View conditions which constitute a role tree aretabulated in a role tree table as units each composed of four items,i.e., a view name, a pattern name, a role name, and a subview name,which constitute view conditions. For example, if a view condition isgiven as "situation to calculate change=change calculation (amountgiven:Y, amount to pay:Z, change:X)", then the role tree table containsview names, pattern names, role names, and subview names for the threeroles "amount given" "amount to pay", and "change".

FIG. 32 is a diagram showing a process of expressing a role treetransformation rule in the third processor. As with the role tree table,a role tree transformation rule table tabulates view conditions whichconstitute a rule, as units each composed of four items, i.e., a viewname, a pattern name, a role name, and a subview name, which constituteview conditions. The role tree transformation rule table also has a setof additional information per unit of four items, the additionalinformation including a matched status recording a matched position atthe time a unit of four items is compared with a role tree, a matchingcondition indicative of whether there is a negating operation "˜"relative to a matching/adding process, etc. For example, if the roletree transformation rule is given as "{¥x=conditionalaction(condition:failure, content:¥y)→¥x=ifCarry(content:¥y,label:¥new)" then the role tree transformation rule table contains tworoles "condition", "content" and two roles "content" "label" for pre-and post-conditional parts of the role tree transformation rules, andfurthermore information regarding whether there is a negating symbol "˜"and a matched status with respect to each of the above four roles.

FIG. 33 is a diagram showing a variable table for holding the values ofvariables contained in a role tree transformation rule. The variabletable holds the variables which a role tree transformation rule containsand the values of the variables as a result of matching, with thevariables and their values being held in corresponding relationship toeach other.

FIG. 34 is a flowchart of a processing sequence of the third processor.The third processor 35 is composed of a program entitled "trans.exe"that operates under MS-DOS, for example. By executing this program, thethird processor 35 receives a beginning role tree 34 and generates anending role tree 36 according to the set 40 of role tree transformationrules.

It is shown in FIG. 34 that when the matching between thepre-conditional part of a rule and a role tree is successful, then apartial role tree constructed from the post-conditional part of the treeis forcibly added to the role tree. The rules are continuously appliedinsofar as the pre-conditional part is matched with the role tree. Ifthe matching of the pre-conditional part is never successful, then theapplication of the rules fails.

FIG. 35(A) and FIG. 35(B) are flowcharts of a procedure for matching apre-conditional part. View conditions which constitute a pre-conditionalpart are matched, one by one, with a role tree. Specifically, prior to anegating operation "˜" relative to matching, a view condition and therole tree are first matched, and then the success/failure of thematching is determined based on whether there is a negating operation"˜" or not. If the matching between a view condition free of a negatingoperation "˜" and the role tree is successful, then the value of avariable in the pre-conditional part is determined. If the matching of aview condition unit fails, then control returns to a preceding viewcondition, and the matching is effected again. If the matching of allview conditions is successful, then the matching of the pre-conditionalpart is successful. If no view condition to return to is available whenthe matching is to be effected again, then the matching of thepre-conditional part fails.

FIG. 36 is a flowchart of a procedure for matching four items whichconstitute a view condition of a role tree transformation rule with arole tree. Four items (4 tuples) are successively extracted from adesignated view condition, and matched with a role tree. If the matchingis successful, then the value of a variable is determined, and theposition where the matching on the role tree is successful is recordedas a matched status. If the matching between the four items and the roletree is successful, then next four items are extracted for matching. Ifthere are no next four items, i.e., if the matching of all four items issuccessful, then the matching between the view condition and the roletree is successful. If the matching fails, then the matching is effectedagain from preceding four items. If preceding four items are notavailable when the matching is effected again, the matching between theview condition and the role tree fails.

FIG. 37 is a flowchart of a procedure for constructing a partial roletree from the post-conditional part of a role tree transformation rule.Four items which constitute a post-conditional part are extracted, andthe value of a variable determined by the matching of a pre-conditionalpart is substituted. The four items obtained as a result are forciblyadded to a role tree.

FIG. 38(A) and FIG. 38(B) are flowcharts of a procedure for forciblyadding four items. When the four items are to be forcibly added, theyare inserted after confirming that the four items to be added are notcontradictory to the role tree. If the four items are contradictory tothe role tree, then the old role tree is rewritten to eliminate thecontradictory factor, and thereafter the four items are inserted. Tosimplify a procedure, described below, to eliminate the contradictoryfactor, four items, i.e., a view, a pattern, a role, and a subview, onthe side of the role tree are represented by upper-case letters VPRS,and these four items on the side of the rule are represented bylower-case letters vprs. The generation of a contradictory situation ischecked in the order of v→p→r→s.

When the checking process proceeds to vp, it is verified that all theelements vPRS where v=V satisfy p≈P. If successful, then all four itemswhich have vP on the role tree are deleted, and vprs are added.

In the event of a failure, then when the checking process proceeds tovpr, if four items already exist on the role tree which satisfy V=v,P=p, and R=r, then the four items vprS are deleted from the role tree,and then vprs are added. If four items do not exist on the role treewhich satisfy V=v, P=p, and R=r, then vprs are added.

Finally, vprs are added. First, it is verified whether the treestructure is destroyed or not for the reasons:

(1) there is formed a path beginning from a subview s, followingsuccessive views, and reaching the subview s itself, and

(2) a plurality of intermediate views are produced, as a result ofadding vprs. If there is formed a path beginning from a subview s,following successive views, and reaching the subview s itself, then fouritems in the form of VPRv are deleted from the role tree, then fouritems in the form of VPRs are deleted from the role tree, and thereaftervprs are added, thus ending the forcible addition process. If aplurality of intermediate views are produced, then the four items in theform of VPRs are deleted from the role tree, and thereafter vprs areadded, thus ending the forcible addition process. If the additionprocess does not destroy the tree structure, then vprs are added, thusending the forcible addition process.

The fourth processor 37 shown in FIG. 5(C) is composed of a programentitled "showV. exe" that operates under MS-DOS, for example. Byexecuting this program, the fourth processor 37 uses the set 41 ofpatterns and the set 42 of vocabularies, and generates a computerprogram source code 38 corresponding to the second linguisticdescription from the ending role tree 36. The fourth processor 37 usesthe top view file 45 in order to designate a partial role tree which isused to generate computer programming linguistic descriptions. Formanaging a file group used, the fourth processor 37 refers to theexpression generation control file 44.

FIG. 39 is a diagram showing the content of an expression generationcontrol file used for the fourth processor to generate computerprogramming linguistic descriptions from the ending role tree. Theexpression generation control file has a file name "tst.ish". Theexpression generation control file 44 has four elements designated,i.e., an input role tree (RoleTree), a role pattern character string(pattern), a vocabulary view character string (voc), a top view (top),and a destination for storing an expression character string (output).For the patterns, there are designated a plurality of files including aset of common-use patterns and a set of individual-use patterns. For thevocabularies, there are designated a plurality of files including a setof common-use vocabularies and a set of individual-use vocabularies.

FIGS. 40 through 43 show sets of role pattern character strings and setsof vocabulary view character strings which are referred to in theexpression generation control process. Each of the sets is composed of aset of descriptions that make role pattern names or vocabulary viewnames correspond to character strings which represent the contents ofthe names.

FIG. 40 is a diagram showing a set of patterns inherent in problems. Theset of patterns has a file name "tst.pat". In the illustrated example,those character strings which are representative of patterns related tothe calculation of change are collected from role patterns. Thosecharacter strings on the left-hand sides of the delimiter symbols "="are character strings representing pattern names. Those characterstrings on the right-hand sides of the delimiter symbols "=" up to thedelimiter symbols "▴" are character strings representing the contents ofpatterns. The delimiter symbol "=" assigns a character string to a rolepattern of fixed length. A character string which is sandwiched between"" and "" indicates a role name. A character string which is notsandwiched between "" and "" describes an inter-object relationshipwhich defines a role. A row of characters separated by a role namesandwiched between "" and "" is called a "key". If a key is indicated byk and a role name by r, then a general format of a character stringassigned to a fixed-length role pattern is given as:

    k.sub.1 r.sub.1 k.sub.2 . . k.sub.n r.sub.n k.sub.n+1.

To the position of a role name in a role pattern character string, thereis assigned a character string representing an object which plays a rolerepresented by the role name. An expression generating procedure for afixed-length role pattern character string is as follows: An i-th key ona role pattern character string is outputted, then a character string ofa subview determined from an i-th role name and the role assignment of arole tree is generated, and a next key position is set to i (i←i+1),after which control returns. Such a process is repeated.

FIG. 41(A) and FIG. 41(B) are diagrams showing a set of common-usepatterns by way of example. The set of common-use patterns has a filename "begin.pat". In the illustrated example, those patterns which arerelated to the expressions of source codes of a macro assemblerprogramming language are collected from role patterns. As with thedelimiter symbol "=" the delimiter symbol "→" assigns a character stringto a pattern. However, this delimiter symbol assigns a character stringto a role pattern of indefinite length. A character string assigned to arole pattern of indefinite length is arranged as assigning a repeatedportion successively to subviews. The repeated portion is indicated bysandwiching a repeated character string with delimiter symbols "<", ">",and has a general format of k₁ r₁ k₂ . . k_(n) r_(n) k_(n+1) >K₁ R₁ K₂ .. K_(m) R_(m) K_(m+1) > κ. A character string ahead of the delimitersymbol "<" is referred to as a head, a portion sandwiched between thedelimiter symbols" <", "}" as a repeated portion, and κ is called atail. In a character string assigned to an indefinite-length rolepattern, a character string sandwiched between the delimiter symbols "","" does not have a meaning as a role name, but is simply indicative of aposition to which a character string generated with respect to a subviewis assigned. In an expression generating operation with respect to anindefinite-length role pattern character string, a key output and anexpression character string generation with respect to a subview arerepeated taking care of the following points: First, since a role namein a role pattern character string does not give a clue to obtain asubview name, a subview name is determined from the side of a role tree.To this end, the position on a role pattern character string and theposition on a row of subviews of a role tree are used for determining anoutput status. Secondly, a key immediately before the delimiter symbols"<", ">" has no subview. Therefore, when a key is outputted at thisposition, the position of a subview on a role pattern is not updated.Thirdly, a status indicating the generation of a key output immediatelybefore the delimiter symbols "<", ">" is established in order todetermine whether a key output is immediately before or after thedelimiter symbols "<", ">".

FIG. 42 is a diagram showing a set of vocabularies representative of acollection of object names inherent in problems, by way of example. Theset of vocabularies has a file name "tst.voc" In the illustratedexample, those character strings which are explanatory of objectsrelated to the calculation of change are collected from vocabulary viewcharacter strings. Character strings on the left-hand sides of thedelimiter symbols "=" are character strings indicative of view names,and those on the right-hand sides of the delimiter symbols "=" up to thedelimiter symbols "▴" are character strings indicative of the contentsof views.

FIG. 43 is a diagram showing, by way of example, a set of vocabulariesrepresentative of a collection of object names used by a macro assemblerprogram. The set of vocabularies has a file name "end.voc". In theillustrated example, those character strings which are related to theexpressions of source codes of a macro assembler programming languageare collected from vocabulary view character strings. Although not usedin the examples shown in FIGS. 42 and 43, a delimiter symbol "+" is usedto indicate a file name which contains vocabulary view characterstrings.

FIG. 44 is a diagram showing a top view file by way of example. The topview file has a file name "top". A top view designating a partial roletree for generating expressions are described in the top view file 45.

FIG. 45(A) and FIG. 45(B) are diagrams showing, by way of example,computer program linguistic descriptions which are generated from anending role tree by the fourth processor. A generated source programfile has a file name "tst.asm". In FIG. 45(A) and FIG. 45(B), statementsbeginning with the delimiter symbol "@" indicate reference to a macro.This program can directly be processed by a processing system for amacro assembler of a programing language. It is assumed that a set ofmacros and an execution-time library of existing parts are separatelypresent as reusable objects.

FIG. 46 is a flowchart of a processing sequence of the fourth processor.In FIG. 46, an expression generating procedure reads an ending roletree, a set of patterns, a set of vocabularies, a top view, and anoutput file name, and effects an operation to generate an expressioncharacter string in the fourth processor 37.

FIG. 47(A) and FIG. 47(B) are flowcharts of a procedure for generatingan expression character string. A partial role tree whose expression isto be generated is given as a top view, and the procedure is called. Arefined top view is either a view with a subview or a view without asubview. If a refined top view has no subview, then a vocabulary view ispresent or a succession of indefinite-length role patterns with an emptysubview is present. To generate an expression character string, it ischecked whether a succession of indefinite-length role patterns with anempty subview is present. If it is, then a procedure for generating anempty-subview character string is called. If it is not, then a procedurefor generating a vocabulary view character string is called. If arefined top view has a subview, then keys are successively read from arole pattern character string definition and outputted, and then acharacter string generated from a subview is outputted, repeatedly untilno keys become available. In order to generate an expression characterstring from a subview, the procedure (itself) for generating anexpression character string is applied recursively with a subview as arefined top view.

FIG. 48 is a flowchart of a procedure for generating a character stringwith respect to a vocabulary view. If a vocabulary view character stringis not assigned to the vocabulary view, then a vocabulary view nameitself is outputted as a generated character string. If a vocabularyview character string is assigned to the vocabulary view and a delimitersymbol representing a vocabulary view file name is not added, then thevocabulary view character string is outputted. If a vocabulary viewcharacter string is assigned to the vocabulary view and a delimitersymbol representing a vocabulary view file name is added, then thecontent of a vocabulary view file is copied and outputted as thevocabulary view character string.

FIG. 49(A) and FIG. 49(B) FIG. 49(C) are flowcharts of a process forsuccessively outputting rows of keys of an intermediate view characterstring. In order to use a procedure for outputting a character stringrecursively and to record the position of an outputted key in one rolepattern character string, an output status is established per rolepattern. At the time the process is called, the output status isinitialized to indicate the position of a key to be outputted, with itsvalue updated.

FIG. 50(A) and FIG. 50(B) are flowcharts of a process of determining arelative position in an indefinite-length role pattern character string.Between an order i on a role pattern and a role name position j on arole pattern character string, there are established the followingrelationships if it is assumed that the number of role names in the headis represented by N, the number of role names in the repeated portion byM, the relative position in the repeated portion by off, and arepetition constant by 1:

    j=N+off, and

    i=N+1//M+off.

For expression generation, a calculation to determine the value of offfrom i is required. The value of off is determined as the remainder(shown by "//") of an integer division.

FIG. 51 is a flowchart of a sequence for processing the tail of apattern character string. The processing sequence shown in FIG. 51 is asubsequent processing sequence when subview strings of a role pattern onthe side of a role tree are used up while a role pattern characterstring is being outputted, in outputting an indefinite-length rolepattern character string. If subview strings are used up in the head,then remaining keys in the head are outputted, and the repeated portionis skipped, and tail keys are outputted, whereupon the procedure isfinished. If subview strings are used up in the repeated portion, thenremaining keys in the repeated portion are outputted, and the tail isoutputted, whereupon the procedure is finished.

FIG. 52 is a diagram showing, by way of example, the generation of amultilingual document by changing patterns. In FIG. 52, a role tree isindicated by RT, and a generated result GR1 can be obtained by applyinga pattern P1 to the role tree RT. Another generated result GR2 can beobtained by applying a pattern P2 to the same role tree RT. A generatedresult GR3 can be obtained by applying a pattern P3 to the role tree RT.A generated result GR4 can be obtained by applying a pattern P4 to therole tree RT. A generated result GR5 can be obtained by applying apattern P5 to the role tree RT. In this manner, various languagedocuments can be generated from the same pattern simply by changingpatterns, i.e., the role tree can be reused.

A delimiter symbol identifying process capable of identifying adifferent delimiter symbol for each input data item, i.e., identifying adelimiter symbol in a delimited-word file which does not depend on aprocessing system, when data to be processed by a computer arestructured, stored, and referred to, will be described below withrespect to the extraction of a referred-to statement as an example.

With respect to a data structure (data generated based on certainregulations) to be processed by a computer, program source codes, etc.,the structural relationship between elements of the data can beidentified by inserting delimiters between the elements for judging acharacter string of a source code, for example, as one analytic unit.

Generally, delimiter symbols are determined for each processing systemto which a certain program language or a data structure corresponds. Itis necessary to identify delimiter symbols inherent in each processingsystem without depending on the processing system.

FIG. 53 is a diagram showing the principles of a means for identifyingdelimiter symbols. In FIG. 53, the means for identifying delimitersymbols comprises a text storage unit 50, a delimiter symbol processor51, a data processor 52, and a delimiter symbol storage unit 53.

The text storage unit 50 stores texts structured by inserted delimitersymbols for identifying certain data portion from other data portions,and a delimiter definition part positioned at the beginning of the textsand including extracted delimiter symbols used in the texts, in aprogram source code or computer data to be processed by a program.

FIG. 54 is a flowchart of a process of processing delimiter symbols. Thedelimiter symbol processor 51 starts being supplied with delimitersymbols of the delimiter definition part from the text storage unit 50in a processing step S1, and registers the order of supply of thesupplied delimiter symbols as a symbol identifier, as added to thedelimiter symbols, in the delimiter symbol storage unit 53 in aprocessing step S2. Then, the delimiter symbol processor 51 starts beingsupplied with a text from the text storage unit 50 while checkingwhether there is a delimiter symbol or not in a processing step S3. Whenthe delimiter symbol processor 51 detects a delimiter symbol while beingsupplied with the text, the delimiter symbol processor 51 searches thedelimiter symbol storage unit 53 using the detected delimiter symbol asa key in a processing step S4. In a processing step S5, the delimitersymbol processor 51 sends the symbol identifier added to the detecteddelimiter symbol and the data of the text which has been supplied untilthe detected delimiter symbol appears, to the data processor 52. Thedata processor 52 recognizes the delimiter symbol based on the symbolidentifier, and processes the data as desired in a processing step S6.If the supply of a next text is desired, the data processor 52 requeststhe delimiter symbol processor 51 to be supplied with the next text fromthe text storage unit 50 in a processing step S7.

Therefore, for reading a signal train composed only of delimiter symbolsheld by the delimiter definition part from the delimiter symbol storageunit 53, the delimiter symbol processor 51 reads the signal traintogether with the order of supply as a symbol identifier. When thesupply of a text from the delimiter symbol storage unit 53 is started,the delimiter symbol processor 51 sends the data of the text which hasbeen supplied until a delimiter symbol appears and the symbol identifierof the delimiter symbol to the data processor 52, which processes thesupplied data based on the symbol identifier sent thereto. Accordingly,it is possible to identify delimiter symbols even if different delimitersymbols are used in connection with respective texts.

FIG. 55 is a diagram of a system for processing data including delimitersymbols. The data processing system shown in FIG. 55 comprises aprocessing device 60, a system console 70 having a display unit withinputting and outputting capabilities, and a disk device 80 having atext storage unit 50 which stores document files 501, 502, 503 and areferred-to statement storage unit 55. The processing device 60comprises a controller 61, an input/output control unit 62, a delimitersymbol processor 51, a data processor 52, a delimiter symbol storageunit 53, and an input buffer 63.

The controller 61 has a function to control an operating system, and theinput/output control unit 62 controls the disk device 80 to read andwrite data.

FIG. 56 is a diagram showing the structure of the document files. InFIG. 56, the texts of the document files 501, 502, 503 are composed ofrespective delimiter definition parts 511, 512, 513 and respective dataparts 521, 522, 523.

The delimiter definition parts 511, 512, 513 are composed of respectivetrains of all delimiter symbols (two delimiter symbols in thisembodiment) extracted from at least the data parts 521, 522, 553 andarranged in a predetermined order (e.g., "" after ""), the delimitersymbol trains being sandwiched between symbols (delimiter symbols "▪"provided to distinguish the delimiter definition parts 511, 512, 513from the data parts 521, 522, 523) which are not used in the data parts521, 522, 523. It is assumed that the data parts 521, 522, 523 employdifferent delimiter symbols, per every document file of 501, 502, 503,i.e., the document file 501 employs delimiter symbols "", "" for thedocument file 502, the document file 503 employs delimiter symbols "[","]", and data part 523 employs delimiter symbols ".left brkt-top.",".right brkt-bot.".

A process of extracting a referred-to statement composed of a characterstring sandwiched between delimiter symbols in the data parts 521, 522,523 from the document files 501, 502, 503 which have different datastructures (employ different delimiter symbols) will be described belowwith reference to a procedure for extracting a referred-to statementshown in FIG. 57(A) and FIG. 57(B).

In FIG. 57(A), the operator inputs a start command to the controller 61for starting the data processor 52, and the controller 61 starts thedata processor 52 in a processing step S11. The started data processor52 displays a message for prompting the inputting of the file name of adocument file from which a referred-to statement is to be extracted, onthe display unit (not shown) of the system console 70 in a processingstep S12.

The operator inputs the file name of a document file 50i (i=1, 2, 3)from the system console 70, and the data processor 52 reads the filename in a processing step S13.

In a processing step S14, the data processor 52 indicates the inputtedfile name to the delimiter symbol processor 51 to request the delimitersymbol processor 51 to read the document file 50i.

In a processing step S15, the delimiter symbol processor 51 startsreading the document file 50i from the disk device 80 through theinput/output controller 62.

The delimiter symbol processor 51 which has started reading the documentfile 50i reads a symbol train from the first delimiter symbol "▪" to thenext same delimiter symbol, adds numbers to the delimiter symbols in theorder in which they are read, and registers them in the delimiter symbolstorage unit 53 in a processing step S16.

FIG. 58 is a diagram illustrative of symbol identifiers registered inthe delimiter symbol storage unit 53. In FIG. 58, the delimiter symbolprocessor 51 reads a symbol train from the delimiter symbol "▪" at thebeginning of a file to the next same delimiter symbol, i.e., for thedocument file 501, for example, the delimiter symbol processor 51 readsthe delimiter symbols "", "", adds numbers to them in the order in whichthey are read, that is, adds "1" to the delimiter symbol "" and adds "2"to the delimiter symbol "", and registers them in the delimiter symbolstorage unit 53.

In FIG. 57(A) and FIG. 57(B), when the delimiter symbol processor 51reads the next delimiter symbol "▪", it recognizes that it has completedthe reading of the delimiter definition parts 511, 512, 513, and thenstarts reading the data part 52i (i=1, 2, 3) in a processing step S17.

In a processing step S18, while reading the data part 52i, the delimitersymbol processor 51 checks whether there is a delimiter symbol or not inthe read data. The read data are stored in the input buffer 63.

If there is no delimiter symbol in the read data, then the delimitersymbol processor 51 determines whether the reading of all the data part52i is completed or not in a processing step S19. If completed, thedelimiter symbol processor 51 indicates the completion to the dataprocessor 52, and the data processor 52 completes the processing ofdata.

If there is a delimiter symbol in the read data, then the delimitersymbol processor 51 searches the delimiter symbol storage unit 53 usingthe delimiter symbol as a key, and indicates the symbol identifiercorresponding to the delimiter symbol and the data that have beeninputted to the input buffer 63 until the delimiter symbol appears, tothe data processor 52 in a processing step S20.

In a processing step S21, the data processor 52 checks the indicatedsymbol identifier.

If the symbol identifier "1" is indicated, then the data processor 52ignores the inputted data in a processing step S22. If the symbolidentifier "2" is indicated, then the data processor 52 writes the datain the input buffer 63 into the referred-to statement storage unit 55 ofthe disk device 80 through the input/output controller 62 in aprocessing step S23.

Following the processing step S22 or S23, the data processor 52 requeststhe delimiter symbol processor 51 to indicate next data inputting and adelimiter symbol, and control returns to the processing step S18.

By thus reading the delimiter definition part 51i and the data part 52iof the document file 50i (i=1, 2, 3), it is possible to extract areferred-to statement sandwiched between delimiter symbols from thedocument file 50i which has different delimiter symbols. Therefore, evenif a plurality of role tree files or other files employ differentdelimiter symbols, no confusion arises between the files as the relativeposition of delimiter symbols among the delimiter symbols is controlledper file.

As described above, the present invention offers the followingadvantages:

According to the first advantage, the format of an initial document canfreely be selected. Specifically, since an initial document istransformed into a designated document structure using a role tree,character string expressions themselves which constitute the initialdocument can freely be selected. Transformation from a documentstructure as an initial document into a document structure as a programis determined subsequently according to role tree transformation rules.As a result, inasmuch as an abstract program can be produced with anindividual language, 1 the programmer can generate and accumulate inexpressions that can easily be understood and confirmed himself, and canreduce the working cost of the programmer, 2 the programmer can producean abstract program while subsequently applying detailed meanings by wayof computer operation when a program is to be generated, and 3 theprogrammer does not need to write a program in a programming languagethat has been provided.

According to the second advantage, the decision of implementation isavailable in the form of data. Since the decision of implementation hasbeen converted into data using role tree transformation rules, animplementing process for detailing an abstract program into a specificprogram is given as data. Consequently, 1 a programming process can beautomatized, i.e., if a variable is used, then a declare statement canautomatically be entered, 2 the programmer can accumulate and reuseprogramming experiences as data, 3 since all are available as data and aprocedure according to which a specific program has been transformedinto an abstract program remains objectively, an implementing processcan be reproduced in its entirety, and 4 a plurality of versions cansimultaneously be generated by using a plurality of implementing data.

According to the third advantage, expression data of different languagesare available in the form of data. By exchanging a set of role patternsindicating language expressions and a set of vocabularies, it ispossible to derive a plurality of language expressions in, e.g., a Clanguage, FORTRAN, COBOL, an assembler language, etc., from the samerole tree. Since a final program language can freely be selected, 1expressions can be formed in a desired programing language, and 2expressions can be generated simultaneously in a plurality ofprogramming languages.

According to the fourth advantage, computer program parts can be reused.Because different programs can be generated in the same format logic ofthe same initial document, 1 programs can be generated and accumulatedby selecting expressions that can easily be understood by the user, 2 aprogramming language can be changed by changing transformation rules andexpression data (a set of patterns and a set of vocabularies), and it isnot necessary to change the accumulated programs themselves, 3 aprocedure for obtaining a source code from accumulated abstract programscan be automatized by reusing transformation rules and expression data,and 4 a process of reusing existing subroutines can easily beautomatized by adding a set of transformation rules, a set of patterns,and a set of vocabularies which correspond to operations for insertingstatements to call the subroutines.

According to the fifth advantage, the following advantages can beachieved by making improvements in operation:

1 By expressing expressions used in an abstract program with words in anapplication field, a program language specifically related to thatapplication field can be produced. For example, insofar as the manner inwhich an initial document is written is determined, the programgenerating system can be used as a kind of compiler.

2 By using only expressions which are not governed by the circumstancesof a computer as an abstract programing language, it is possible togenerate an abstract program of long service life (i.e., which is almostfree of the need for change depending on the programming language), sothat capability of reusing programs is increased.

3 Changes in the circumstances of a computer can be met only by alteringand correcting data for indicating an implementing process.

4 With regard to a general implementing process, many of data forindicating an implementing process can be reused, and it may besufficient to indicate only implementing techniques of the program.

5 Programs in a plurality of versions, e.g., a debugging version, a testversion, etc., can simultaneously be generated by giving instructionswith data as implementing techniques.

6 Programming languages can be transformed by changing data(implementing data, a set of patterns, and a set of vocabularies).

7 For debugging a program, the causes of debugs may be classified intothree categories, i.e., (a) abstract program bugs, (b) implementingprocess bugs, and (c) programming language usage errors.

8 Since information used in programing and a process of programingoperation can be reproduced, problems arising out of the differencebetween the programer and the service person can be coped with.

9 Test data or the like can systematically be generated by this tool.

According to the sixth advantage, the program generating system can beapplied to other fields than programming. For example, 1 it can generatenot only programs but also data in the same manner as the programs, 2 itcan generate natural language expressions such as language translationsor the like, and 3 it can transform structured texts.

We claim:
 1. A program generating system for using the language of anindividual to generate a linguistic description expressed in aprogramming language from a linguistic description expressed in thelanguage of a user, comprising:means for carrying out a first processfor transforming a user's linguistic expression into an initial roletree; means for carrying out a second process for detailing andtransforming a vocabulary expression of said initial role tree into abeginning role tree; means for carrying out a third process fordetailing and transforming said beginning role tree into an ending roletree; and means for carrying out a fourth process for generating asource code of a programming language from said ending role tree.
 2. Aprogram generating system according to claim 1, wherein said means forcarrying out a second process has vocabulary detailing means forapplying vocabulary transformation rules to said initial role tree todetail the vocabulary expression of said initial role tree.
 3. A programgenerating system according to claim 2, wherein said vocabularydetailing means has applying means for successively applying thevocabulary transformation rules to the initial role tree.
 4. A programgenerating system according to claim 3, wherein said applying means hasmatching means for matching a vocabulary of the initial role tree withthe vocabulary transformation rules.
 5. A program generating systemaccording to claim 4, wherein said applying means has means forreconstructing the vocabulary of the initial role tree according to saidvocabulary transformation rules when the matching by said matching meansis successful.
 6. A program generating system according to claim 1,wherein said means for carrying out a third process has transformationrule applying means for applying role tree transformation rules to saidbeginning role tree to detail said beginning role tree.
 7. A programgenerating system according to claim 6, wherein said transformation ruleapplying means has means for successively applying said role treetransformation rules to said beginning role tree.
 8. A programgenerating system according to claim 6, wherein said transformation ruleapplying means has means for repeatedly applying said role treetransformation rules to said beginning role tree.
 9. A programgenerating system according to claim 6, wherein said transformation ruleapplying means has means for matching said beginning role tree with apartial role tree in a pre-conditional part of the role transformationrules.
 10. A program generating system according to claim 6, whereinsaid transformation rule applying means has means for forcibly adding apartial role tree in a post-conditional part of the role treetransformation rules to said beginning role tree according to the resultof matching by said matching means.
 11. A program generating systemaccording to claim 1, wherein said means for carrying out a fourthprocess has means for applying a set of patterns and a set ofvocabularies to said ending role tree.
 12. A program generating systemaccording to claim 1, wherein said role trees have a document structurecomposed of a portion which defines delimiter symbols and a portionwhich has a row of characters separated by delimiter symbols.
 13. Aprogram generating system according to claim 12, wherein said portionwhich has a row of characters is composed of a set of view definitionseach comprising a view and a view content.
 14. A program generatingsystem according to claim 13, wherein said view content is composed of apattern and a series of roles and subviews.
 15. A method of identifyingdelimiter symbols in a delimited file in a system having a text storageunit storing texts each structured to identify a given data part fromother data parts with sandwiching delimiter symbols and delimiterdefinition parts positioned at the beginning of said texts and includingextracted delimiter symbols used in said texts, in a source code of aprogram and computer data to be processed by a program, a delimitersymbol processor, a data processor, and a delimiter symbol storage unit,said method comprising the steps of:(S1) starting to input the delimitersymbols of said delimiter definition parts from said text storage unitwith said delimiter symbol processor; (S2) adding the order in whichsaid delimiter symbols are inputted as symbol identifiers to saiddelimiter symbols and registering the symbol identifiers and thedelimiter symbols in the delimiter symbol storage unit; (S3) starting toinput a text stored in said text storage unit while checking whetherthere is a delimiter symbol; (S4) searching said delimiter symbolstorage unit using a delimiter symbol as a key if said delimiter symbolis detected while said text is being inputted; (S5) indicating thesymbol identifier added to said delimiter symbol and inputted data ofsaid text inputted until said delimiter symbol appears, to said dataprocessor; (S6) recognizing the delimiter symbol based on the symbolidentifier and processing the data as desired with said data processor;and (S7) if a next text is to be inputted, requesting said delimitersymbol processor to input the text from said text storage unit.
 16. Amethod of generating a program using the language of an individual togenerate a linguistic description expressed in a programming languagefrom a linguistic description expressed in the language of a user,comprising the steps of:applying an intermediate output transformingprocess and an intermittent output detailing process to linguisticexpressions of an individual to transform the linguistic expressions ofthe individual into linguistic expressions inherent in a field in aninitial stage; applying an intermediate output transforming process andan intermittent output detailing process to the linguistic expressionsinherent in the filed to transform the linguistic expressions inherentin the field into standard linguistic expressions in an intermediatestage; and applying an intermediate output transforming process and anintermittent output detailing process to the standard linguisticexpressions to transform the standard linguistic expressions intolinguistic expressions representing computer operations in a finalstage, finally obtaining computer program language descriptions in apredetermined programming language.
 17. A method according to claim 16,wherein a linguistic description generating processor is applied to eachof the intermediate output transforming processes to generate abstractprogram language expressions.